﻿#include <iostream>
using namespace std;

//class Stack
//{
//private:
//	int top;
//	int* a;
//	int capacity;
//
//public:
//	Stack(int DefaultCapicity = 4)
//	{
//		a = (int*)malloc(sizeof(int) * DefaultCapicity);
//		if (a == nullptr)
//		{
//			perror("Malloc fail");
//			return;
//		}
//		top = 0;
//		capacity = DefaultCapicity;
//	}
//	//void Init(int DefaultCapicity = 4)
//	//{
//	//	a = (int*)malloc(sizeof(int) * DefaultCapicity);
//	//	if (a == nullptr)
//	//	{
//	//		perror("Malloc fail");
//	//		return;
//	//	}
//	//	top = 0;
//	//	capacity = DefaultCapicity;
//	//}
//
//	void Push(int x)
//	{
//		a[top++] = x;
//	}
//
//	int Top()
//	{
//		return a[top - 1];
//	}
//
//	~Stack()
//	{
//		free(a);
//		a = nullptr;
//		capacity = 0;
//		top = 0;
//	}
//	//void Destroy()
//	//{
//	//	free(a);
//	//	a = nullptr;
//	//	capacity = 0;
//	//	top = 0;
//	//}
//};
//int main()
//{
//	Stack st;
//	//st.Init();有了析构函数，就不需要再调用Init的函数了
//	st.Push(1);
//	cout << st.Top() << endl;
//	st.Push(2);
//	cout << st.Top() << endl;
//	st.Push(3);
//	cout << st.Top() << endl;
//	st.Push(4);
//	cout << st.Top() << endl;
//	//st.Destroy();
//	return 0;
//}

//拷贝构造函数
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date(const Date& d)//浅拷贝
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	bool operator<( const Date& x)//运算符重载
	{
		if (_year < x._year)
		{
			return true;
		}
		else if (_year == x._year && _month < x._month)
		{
			return true;
		}
		else if (_year == x._year && _month == x._month && _day < x._day)
		{
			return true;
		}
		return false;
	}

	//void operator=(const Date& x)//赋值重载函数1(无法连续赋值)
	//{
	//	_year = x._year;
	//	_month = x._month;
	//	_day = x._day;
	//}
	
	//Date operator=(const Date& x)//赋值重载函数2(传值返回的拷贝构造消耗太大)
	//{
	//	_year = x._year;
	//	_month = x._month;
	//	_day = x._day;
	//	return *this;
	//}

	//Date& operator=(const Date& x)//赋值重载函数3(引用返回)
	//{
	//	_year = x._year;
	//	_month = x._month;
	//	_day = x._day;
	//	return *this;
	//}

	Date& operator=(const Date& x)//赋值重载函数4(断言是否为自己赋值给自己)
	{
		if (this != &x)
		{
			_year = x._year;
			_month = x._month;
			_day = x._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

//栈这种则结构需要使用深拷贝
//stack(const stack& st)
//{
//	_a = (int*)malloc(sizeof(int) * st._capacity);
//	if (nullptr == _a)
//	{
//		perror("malloc fail");
//		return;
//	}
//	memcpy(_a, st._a, sizeof(int) * st._top);
//	_top = st._top;
//	_capacity = st._capacity;
//}

int main()
{
	Date d1(2025, 1, 18);
	Date d2(2025, 2, 18);
	cout << boolalpha << (d1 < d2) << endl;
	d2 = d1;
	return 0;
}